/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package ordenar;

import persistencia.Register;
import persistencia.RegisterFile;

/**
 *
 * @author ivan
 */
public class HeapSort implements MethodOrder{

    public boolean ordenar(RegisterFile reg) {

       long i,j,s,f;
       Register r1=new Register(reg.tipoDatosAlmacenados());
       Register r2=new Register(reg.tipoDatosAlmacenados());
       Register valori=new Register(reg.tipoDatosAlmacenados());
       Register r3=new Register(reg.tipoDatosAlmacenados());
       
       long n = reg.registerCount();

       // Primera fase: crear el grupo inicial...
       try{
       for (i = 1; i < n; i++)
       {
           reg.seekRegister(i);
           reg.read(r1);
            s = i;
            f = (s-1)/2;
            reg.seekRegister(f);
            reg.read(r2);
            while (s>0 && r2.compareTo(r1) < 0)
            {
                reg.seekRegister(f);
                reg.read(r3);
                reg.seekRegister(s);
                reg.write(r3);
                s = f;
                f = (s-1)/2;
            }
            reg.seekRegister(s);
            reg.write(r1);
       }

       // Segunda fase: se extrae la raiz, y se reordena el vector y el grupo...
       for (i = n-1; i>0; i--)
       {
           reg.seekRegister(i);
           reg.read(valori);
           reg.seekRegister(0);
           reg.read(r1);
           reg.seekRegister(i);
           reg.write(r1);
           f = 0;
            if (i == 1) s = -1; else s = 1;
           reg.seekRegister(2);
           reg.read(r1);
           reg.seekRegister(1);
           reg.read(r2);
           if(i > 2 && r1.compareTo(r2) > 0) s=2;
           if(s >= 0)
           {
               reg.seekRegister(s);
               reg.read(r1);               
           }

            while ( s >= 0 && valori.compareTo(r1) < 0)
            {
                reg.seekRegister(s);
                reg.read(r1);
                reg.seekRegister(f);
                reg.write(r1);
                f = s;
                s = 2*f + 1;
                if(s + 1 <=(i -1))
                {
                    reg.seekRegister(s+1);
                    reg.read(r2);
                    if(r1.compareTo(r2) < 0) s++;
                }                    
                if (s > i - 1) s = -1;
            }
           reg.seekRegister(f);
           reg.write(valori);
       }
       }catch(Exception e){return false;}
       return true;
    }
    public String toString()
    {
        return "HeapSort o monticulo";
    }
}
